Спринт 2/18 → Тема 5/6: Требования к коду → Урок 3/7

Аннотация типов. Простые типы

Никто не застрахован от ошибок в коде. Иногда ценой ошибок бывает просто нечитаемость кода, а иногда — разбившийся космический корабль.
Одна из возможных проблем — ошибка в типах данных.
Python поддерживает динамическую типизацию. Это значит, что переменная получает свой тип не в момент её объявления, а когда ей присваивается значение. Таким образом, в разных участках кода одна и та же переменная может иметь разный тип.
PYTHON
# Создана переменная, ей присвоено значение типа string.
var = "string here"

# Переменной присваивается новое значение, и вот уже тип данных — integer.
var = 1234
Обычно это удобно, но иногда становится отличным способом «выстрелить себе в ногу».
Посмотрите на поведение простой функции:
КодPYTHON
Но никто не мешает передать в функцию we_crash_all() булеву переменную (разработчик вполне может не учесть возможность такого события):
КодPYTHON
Ошибка! В Python нельзя просто взять и сложить str c bool. Функция ожидала на вход строку, а пришло булево значение.
Другой пример: функция speak_up() принимает на вход коллекцию и ожидает, что у неё есть методы pop() и append(). Второй метод доступен только для списков, но ничто не мешает случайно или намерено в ходе написания программы передать функции, например, множество.
Запустите код и посмотрите, что получится:
КодPYTHON
Привет, name, мы всё сломали.
Если кода немного — ошибку легко предотвратить: каждое значение — как на ладони. Но когда в проекте будет взаимодействовать множество функций, классов и переменных — несоответствие типов может стать серьёзной проблемой.

Type Hints: аннотация типов данных

Чтобы держать типизацию под контролем — применяют аннотации типов данных (Type Hints, дословный перевод с английского — «подсказки типов»). Это явное указание типа ожидаемых данных при объявлении переменных, классов и функций.
PYTHON
# Без аннотации: объявили переменную, 
# а Python сам догадался, какой в ней тип данных.
birth_year = 1971

# С аннотацией: объявили переменную и указали, 
# что это переменная только для целых чисел.
birth_year: int = 1971
При выполнении кода интерпретатор Python игнорирует аннотации типов и не выдаёт ошибок, если типизация нарушена:
PYTHON
# Переменная var_for_bool аннотирована как булева, но в неё передана строка.
var_for_bool: bool = 'Чистая правда, клянусь'

# Python не обратит внимания на это несоответствие 
# и продолжит выполнять код как ни в чём не бывало.
# Аннотация будет проигнорированна, переменная будет воспринята
# Python как строка.
Python не обратит внимания на это несоответствие и продолжит выполнять код как ни в чём не бывало. Аннотация будет проигнорирована, переменная будет воспринята Python как строка.
Однако Python не оставляет аннотации совсем без внимания: он считывает Type Hints и сохраняет их в словарь __annotations__. Содержимое этого словаря можно вывести на экран:
PYTHON
# Аннотация переменной name: "это строка".
name: str = 'Наташа'

# Аннотация переменной var_for_bool: "это булева переменная".
var_for_bool: bool = True

# Можно напечатать аннотации переменных из глобальной области видимости.
print(__annotations__)
>>> {'name': <class 'str'>, 'var_for_bool': <class 'bool'>}

Синтаксис аннотирования встроенных типов данных

В простейшем случае аннотация содержит непосредственно ожидаемый тип данных: str, int, float или bool. Дополнительно применяется обозначение None, «ничего»: например, если функция ничего не возвращает — тип возвращаемых данных указывается как None.
Type Hints для переменных
Переменные в Python обычно аннотируются так:
PYTHON
# Только целочисленные значения.
var_integer: int = 10  
# Числа с плавающей точкой (включая целые, можно передать 10).
var_float: float = 10.0  
# Логический тип.
var_flag: bool = True  
# Строки.
var_string: str = 'Йя строка'
В Python есть и другой синтаксис аннотирования, вы можете встретить его в работе. Этот синтаксис устарел, но вполне валиден и нормально обрабатывается пакетами для проверки типов:
PYTHON
# Вариант 1:
<имя переменной>: <принимаемый тип> = <значение>
# Вариант 2: тип данных указывается после символа #.
<имя переменной> = <значение>  # type: <принимаемый тип>.

# На примере birth_year типа int со значением 1971 синтаксис будет выглядеть так:
# Вариант 1:
birth_year: int = 1971

# Вариант 2 (устаревший, использовался до python 3.5):
birth_year = 1971  # type: int
Type Hints для функций
В функциях указывают Type Hints для аргументов и возвращаемого значения:
PYTHON
def <имя функции>(<аргумент>: <тип>) -> <возвращаемый тип>:

def is_rhomb(a_size: float, b_size: float) -> bool:
    """Проверяет, является ли параллелограмм ромбом."""
    # Вернёт True или False в зависимости от истинности выражения.
    return a_size == b_size  
 

# Функция print_hi() ожидает строковый аргумент, 
# значение этого аргумента по умолчанию — 'stranger'.
# Функция ничего не возвращает, и для неё тип возвращаемых данных — None.
def print_hi(name: str = 'stranger') -> None:
    print('Hi,' + name + '!')

# Можно напечатать типы данных функций.
print(is_rhomb.__annotations__)
>>> {'a_size': <class 'float'>, 'b_size': <class 'float'>, 'return': <class 'bool'>}

print(print_hi.__annotations__)
>>> {'name': <class 'str'>, 'return': <class 'None'>}

Ну и кому нужны эти Type Hints?

Если Python игнорирует аннотации типов, а разработчик и без аннотаций старается отслеживать корректность кода — какой прок в этих Type Hints?
Аннотации типов могут считываться сторонними программами, предназначенными для проверки типизации. В случае обнаружения ошибок эти программы сообщат разработчику о проблемах.
Есть четыре популярных пакета для проверки типов: 
  • Mypy активно разрабатывается, в частности, Гвидо ван Россумом, создателем Python. Один из самых популярных пакетов для работы с аннотациями в Python.
  • Pyre — альтернатива mypy.
  • Pytype — анализатор от Google.
  • Pylance — разработан корпорацией Майкрософт.
Эти пакеты могут работать и в терминале, и в редакторе кода (например, как Pylance в VSCode). Такие пакеты подсвечивают некорректный код и выдают подсказки в процессе набора текста.

Проверка аннотации типов через консоль

Теперь можно посмотреть, как работает проверка типизации. Скопируйте этот код во временный файл и сохраните его под именем temp.py (или любым другим):
PYTHON
def we_crash_all(name: str) -> str:    
    return 'Привет, ' + name + ', мы всё сломали!'

print(we_crash_all('Наташа'))
Для проверки файлов на соответствие указанным аннотациям установите пакет mypy в ваше виртуальное окружение:
BASH
pip install mypy
Перейдите в директорию с файлом temp.py и запустите этот файл утилитой mypy:
BASH
mypy temp.py
Success: no issues found in 1 source file
Файл проверен, ошибок в типизации не найдено.
Отредактируйте и сохраните код в файле temp.py:
PYTHON
def we_crash_all(name: str) -> str:    
    return 'Привет, ' + name + ', мы всё сломали!'

print(we_crash_all(100))
Снова запустите файл в mypy:
BASH
mypy temp.py
temp.py:5: error: Argument 1 to "we_crash_all" 
has incompatible type "int"; expected "str"
Found 1 error in 1 file (checked 1 source file)
Утилита mypy сделала своё дело:
  • обнаружила, что в функцию передали число, хотя ожидалась строка;
  • указала на суть ошибки и на строку, в которой допущена ошибка.

Проверка типизации через редактор кода

Вызовите командную строку VSCode (Ctrl+Shift+P), введите в поисковую строку текст Python: Select Linter, нажмите Enter, в выпадающем списке выберите линтер mypy:
Теперь mypy будет постоянно наблюдать за кодом, который вы пишете, а при виде ошибки будет нервничать и, не ожидая выполнения кода, сообщать о проблеме: подчеркнёт ошибку в коде и покажет детальное описание в панели «Проблемы» (Problems).
Стоит рассматривать инструмент для проверки типов как дополнительный линтер, необязательный, но полезный.
Ещё один шаг к аккуратному коду сделан. Пока больше теоретический; значит, пора практиковаться.